package com.cl.code.common.utils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Objects;

/**
 * 集合工具类
 *
 * @author chengliang
 * @since 1.0.0
 */
public class CollectionUtils {

    /**
     * 判断集合是否为空
     *
     * @param collection 集合
     * @param <T>        集合元素类型
     * @return 是否为空
     */
    public static <T> boolean isEmpty(Collection<T> collection) {
        return !isNotEmpty(collection);
    }

    /**
     * 判断集合是否不为空
     *
     * @param collection 集合
     * @param <T>        集合元素类型
     * @return 是否不为空
     */
    public static <T> boolean isNotEmpty(Collection<T> collection) {
        return collection != null && !collection.isEmpty() && collection.stream().anyMatch(Objects::nonNull);
    }

    /**
     * 合并两个集合
     *
     * @param collection1 集合1
     * @param collection2 集合2
     * @param <T>         集合元素类型
     * @return 合并后的集合
     */
    public static <T> List<T> merge(Collection<T> collection1, Collection<T> collection2) {
        List<T> mergeList = new ArrayList<>();
        if (isNotEmpty(collection1)) {
            mergeList.addAll(collection1);
        }
        if (isNotEmpty(collection2)) {
            mergeList.addAll(collection2);
        }
        return mergeList;
    }

    /**
     * 移除集合中的重复元素
     *
     * @param collection 集合
     * @param <T>        集合元素类型
     * @return 移除重复元素后的集合
     */
    public static <T> List<T> removeDuplicates(Collection<T> collection) {
        List<T> newList = new ArrayList<>();
        for (T element : collection) {
            if (!newList.contains(element)) {
                newList.add(element);
            }
        }
        return newList;
    }

    /**
     * 获取两个集合的交集
     *
     * @param collection1 集合1
     * @param collection2 集合2
     * @param <T>         集合元素类型
     * @return 交集
     */
    public static <T> List<T> intersection(Collection<T> collection1, Collection<T> collection2) {
        List<T> intersectionList = new ArrayList<>();
        for (T element : collection1) {
            if (collection2.contains(element)) {
                intersectionList.add(element);
            }
        }
        return intersectionList;
    }

    /**
     * 获取两个集合的并集
     *
     * @param collection1 集合1
     * @param collection2 集合2
     * @param <T>         集合元素类型
     * @return 并集
     */
    public static <T> List<T> union(Collection<T> collection1, Collection<T> collection2) {
        ArrayList<T> unionList = new ArrayList<>(collection1);
        for (T element : collection2) {
            if (!unionList.contains(element)) {
                unionList.add(element);
            }
        }
        return unionList;
    }

    /**
     * 获取两个集合的差集
     *
     * @param collection1 集合1
     * @param collection2 集合2
     * @param <T>         集合元素类型
     * @return 差集
     */
    public static <T> List<T> difference(Collection<T> collection1, Collection<T> collection2) {
        List<T> differenceList = new ArrayList<>(collection1);
        differenceList.removeAll(collection2);
        return differenceList;
    }

}
